import { Enemy, type EnemyConfig } from '.';
import { ENEMY_DATA } from '../../data/enemy';
import type { RealmBigLevelType } from '../../data/realm';

/**
 * 敌人工厂创建选项接口
 */
export interface EnemyCreateOptions {
  /** 敌人等级（仅等级模式需要） */
  level?: number;
  /** 敌人境界配置 */
  realm?: {
    bigLevelType: RealmBigLevelType;
    smallLevel?: number;
  };
}

/**
 * 敌人工厂类
 * 提供静态方法用于创建和管理敌人实例
 * 支持不同属性成长模式的敌人创建
 */
export class EnemyFactory {
  /**
   * 根据敌人ID创建敌人实例
   * 支持固定属性和等级成长属性两种模式
   * @param enemyId - 要创建的敌人ID
   * @param options - 创建选项
   * @returns 创建的敌人实例
   * @throws 当敌人ID未找到或参数不完整时抛出错误
   */
  public static createEnemy(
    enemyId: string,
    options?: EnemyCreateOptions
  ): Enemy {
    const config = ENEMY_DATA.find((config) => config.id === enemyId);
    if (!config) {
      throw new Error(`未找到ID为 "${enemyId}" 的敌人配置`);
    }

    const mode = config.attributesConfig.mode;

    switch (mode) {
      case 'fixed':
        return this.createFixedAttributeEnemy(config);
      case 'level':
        if (options?.level === undefined) {
          throw new Error('等级成长属性敌人必须提供 level 参数');
        }
        return this.createLevelBasedEnemy(config, options.level, options.realm);
      default:
        // 默认情况下直接创建，但理论上不会执行到这里
        return new Enemy(config);
    }
  }

  /**
   * 创建固定属性的敌人实例
   * @param config - 敌人配置对象
   * @returns 固定属性的敌人实例
   * @throws 当配置缺少固定属性参数时抛出错误
   */
  public static createFixedAttributeEnemy(config: EnemyConfig): Enemy {
    if (config.attributesConfig.fixedAttributes === undefined) {
      throw new Error(
        '固定属性敌人必须提供 attributesConfig.fixedAttributes 参数'
      );
    }

    return new Enemy({
      ...config,
      attributesConfig: {
        mode: 'fixed',
        fixedAttributes: config.attributesConfig.fixedAttributes,
      },
    });
  }

  /**
   * 创建等级成长属性的敌人实例
   * @param config - 敌人配置对象
   * @param level - 敌人的等级
   * @param realm - 敌人的境界配置（可选）
   * @returns 等级成长属性的敌人实例
   * @throws 当配置缺少等级成长参数时抛出错误
   */
  public static createLevelBasedEnemy(
    config: EnemyConfig,
    level: number,
    realm?: {
      bigLevelType: RealmBigLevelType;
      smallLevel?: number;
    }
  ): Enemy {
    if (config.attributesConfig.levelBasedConfig === undefined) {
      throw new Error(
        '等级成长属性敌人必须提供 attributesConfig.levelBasedConfig 参数'
      );
    }

    // 构建属性配置
    const attributesConfig = {
      mode: 'level' as const,
      levelBasedConfig: {
        ...config.attributesConfig.levelBasedConfig,
        initialLevel: level,
      },
    };

    // 如果有境界配置，添加到属性配置中
    if (realm) {
      attributesConfig.levelBasedConfig.initialRealm = {
        bigLevelType: realm.bigLevelType,
        smallLevel: realm.smallLevel || 1,
      };
    }

    return new Enemy({
      ...config,
      attributesConfig,
    });
  }

  /**
   * 批量创建敌人实例
   * @param enemyIds - 敌人ID数组
   * @param options - 创建选项（可选，对所有敌人生效）
   * @returns 敌人实例数组
   */
  public static createEnemies(
    enemyIds: string[],
    options?: EnemyCreateOptions
  ): Enemy[] {
    return enemyIds
      .map((id) => {
        try {
          return this.createEnemy(id, options);
        } catch (error) {
          console.warn(`创建敌人 ${id} 失败:`, error);
          return null;
        }
      })
      .filter((enemy): enemy is Enemy => enemy !== null);
  }

  /**
   * 根据类型筛选并创建敌人
   * @param type - 敌人类型
   * @param options - 创建选项
   * @returns 符合条件的敌人实例数组
   */
  public static createEnemiesByType(
    type: string,
    options?: EnemyCreateOptions
  ): Enemy[] {
    const configs = ENEMY_DATA.filter((config) => config.type === type);
    return configs
      .map((config) => {
        try {
          return this.createEnemy(config.id, options);
        } catch (error) {
          console.warn(`创建敌人 ${config.id} 失败:`, error);
          return null;
        }
      })
      .filter((enemy): enemy is Enemy => enemy !== null);
  }

  /**
   * 验证敌人配置是否有效
   * @param enemyId - 敌人ID
   * @returns 配置是否有效
   */
  public static validateEnemyConfig(enemyId: string): boolean {
    const config = ENEMY_DATA.find((config) => config.id === enemyId);
    if (!config) return false;

    try {
      // 尝试创建实例来验证配置
      if (config.attributesConfig.mode === 'fixed') {
        this.createFixedAttributeEnemy(config);
      } else {
        // 对于等级模式，用默认等级1验证
        this.createLevelBasedEnemy(config, 1);
      }
      return true;
    } catch {
      return false;
    }
  }

  /**
   * 获取所有可用的敌人ID
   * @returns 敌人ID数组
   */
  public static getAvailableEnemyIds(): string[] {
    return ENEMY_DATA.map((config) => config.id);
  }

  /**
   * 获取敌人配置信息（不创建实例）
   * @param enemyId - 敌人ID
   * @returns 敌人配置信息或null
   */
  public static getEnemyConfig(enemyId: string): EnemyConfig | null {
    return ENEMY_DATA.find((config) => config.id === enemyId) || null;
  }
}

// 为了向后兼容，保留旧的工厂方法名（可选的）
export class EnemyFactoryLegacy {
  /**
   * @deprecated 使用 EnemyFactory.createEnemy 代替
   */
  public static createEnemyById(
    enemyId: string,
    options?: { level?: number; realm?: number }
  ): Enemy {
    // 转换旧的境界参数格式
    const modernOptions: EnemyCreateOptions | undefined = options
      ? {
          level: options.level,
          realm: options.realm
            ? {
                bigLevelType: options.realm as any, // 这里需要根据实际情况转换
                smallLevel: 1,
              }
            : undefined,
        }
      : undefined;

    return EnemyFactory.createEnemy(enemyId, modernOptions);
  }
}
